package service

import (
	"context"
	"crypto/md5"
	"crypto/rand"
	"encoding/hex"
	"errors"
	"fmt"
	"regexp"
	"strings"
	"time"

	"github.com/golang-jwt/jwt/v4"
	"github.com/slrun/callcenter/internal/model"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/bson/primitive"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)

// SystemService 系统服务
type SystemService struct {
	MongoDB      *mongo.Database
	JWTSecret    string
	RedisClient  interface{}
	AgentService *AgentService
	services     *Services // 服务集合引用
}

// NewSystemService 创建系统服务实例
func NewSystemService(mongoDB *mongo.Database, jwtSecret string, redisClient interface{}, agentService *AgentService) *SystemService {
	return &SystemService{
		MongoDB:      mongoDB,
		JWTSecret:    jwtSecret,
		RedisClient:  redisClient,
		AgentService: agentService,
	}
}

// InitializeSystem 初始化系统数据
func (s *SystemService) InitializeSystem() error {
	// 创建默认角色
	if err := s.createDefaultRoles(); err != nil {
		return fmt.Errorf("创建默认角色失败: %w", err)
	}

	// 创建默认用户
	if err := s.createDefaultAdminUser(); err != nil {
		return fmt.Errorf("创建默认管理员用户失败: %w", err)
	}

	// 创建默认系统配置
	if err := s.createDefaultSystemConfigs(); err != nil {
		return fmt.Errorf("创建默认系统配置失败: %w", err)
	}

	// 创建默认权限
	if err := s.createDefaultPermissions(); err != nil {
		return fmt.Errorf("创建默认权限失败: %w", err)
	}

	return nil
}

// Login 用户登录
func (s *SystemService) Login(req model.LoginRequest) (*model.LoginResponse, error) {
	// 查找用户
	user, err := s.getUserByUsername(req.Username)
	if err != nil {
		// 记录失败的登录尝试
		s.logLoginAttempt(req.Username, false, "用户不存在")
		return nil, fmt.Errorf("用户名或密码错误")
	}

	// 检查用户状态
	if user.Status != model.UserStatusActive {
		s.logLoginAttempt(req.Username, false, "用户状态异常: "+user.Status)
		return nil, fmt.Errorf("用户账号已被禁用或锁定")
	}

	// 验证密码
	if !s.verifyPassword(req.Password, user.Password) {
		// 增加失败登录次数
		s.incrementFailedLoginAttempts(req.Username)
		s.logLoginAttempt(req.Username, false, "密码错误")
		return nil, fmt.Errorf("用户名或密码错误")
	}

	// 生成JWT令牌
	token, expiresIn, err := s.generateJWT(user)
	if err != nil {
		return nil, fmt.Errorf("生成令牌失败: %w", err)
	}

	// 更新最后登录时间
	user.LastLogin = time.Now()
	if err := s.updateUser(user); err != nil {
		// 记录错误但不影响登录
		fmt.Printf("更新最后登录时间失败: %v\n", err)
	}

	// 记录成功登录
	s.logLoginAttempt(req.Username, true, "登录成功")

	return &model.LoginResponse{
		Token:     token,
		User:      *user,
		ExpiresIn: expiresIn,
	}, nil
}

// ValidateJWT 验证JWT令牌
func (s *SystemService) ValidateJWT(tokenString string) (*jwt.Token, *jwt.MapClaims, error) {
	// 解析JWT令牌
	token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
		// 验证签名算法
		if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
			return nil, fmt.Errorf("意外的签名方法: %v", token.Header["alg"])
		}
		return []byte(s.JWTSecret), nil
	})

	if err != nil {
		return nil, nil, err
	}

	// 验证令牌有效性
	if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
		return token, &claims, nil
	}

	return nil, nil, errors.New("无效的令牌")
}

// ChangePassword 修改密码
func (s *SystemService) ChangePassword(userID string, req model.ChangePasswordRequest) error {
	// 获取用户
	user, err := s.getUserByID(userID)
	if err != nil {
		return fmt.Errorf("获取用户信息失败: %w", err)
	}

	// 验证旧密码
	if !s.verifyPassword(req.OldPassword, user.Password) {
		return fmt.Errorf("旧密码不正确")
	}

	// 验证新密码是否符合策略
	if err := s.validatePassword(req.NewPassword); err != nil {
		return fmt.Errorf("新密码不符合要求: %w", err)
	}

	// 验证新密码是否与历史密码重复
	if s.isPasswordInHistory(userID, req.NewPassword) {
		return fmt.Errorf("新密码不能与最近使用过的密码相同")
	}

	// 更新密码
	hashedPassword := s.hashPassword(req.NewPassword)
	user.Password = hashedPassword

	// 更新用户
	if err := s.updateUser(user); err != nil {
		return fmt.Errorf("更新密码失败: %w", err)
	}

	// 记录密码修改历史
	s.savePasswordHistory(userID, hashedPassword)

	return nil
}

// GetSystemConfig 获取系统配置
func (s *SystemService) GetSystemConfig(key string) (*model.SystemConfig, error) {
	collection := s.MongoDB.Collection("system_configs")
	filter := bson.M{"key": key}

	var config model.SystemConfig
	err := collection.FindOne(context.Background(), filter).Decode(&config)
	if err != nil {
		if err == mongo.ErrNoDocuments {
			return nil, fmt.Errorf("配置项不存在: %s", key)
		}
		return nil, fmt.Errorf("获取系统配置失败: %w", err)
	}

	return &config, nil
}

// GetSystemConfigs 获取系统配置列表
func (s *SystemService) GetSystemConfigs(category string) ([]model.SystemConfig, error) {
	collection := s.MongoDB.Collection("system_configs")
	filter := bson.M{}

	if category != "" {
		filter["category"] = category
	}

	cursor, err := collection.Find(context.Background(), filter)
	if err != nil {
		return nil, fmt.Errorf("获取系统配置列表失败: %w", err)
	}
	defer cursor.Close(context.Background())

	var configs []model.SystemConfig
	if err := cursor.All(context.Background(), &configs); err != nil {
		return nil, fmt.Errorf("解析系统配置数据失败: %w", err)
	}

	return configs, nil
}

// UpdateSystemConfig 更新系统配置
func (s *SystemService) UpdateSystemConfig(key string, value interface{}, updatedBy string) (*model.SystemConfig, error) {
	collection := s.MongoDB.Collection("system_configs")
	filter := bson.M{"key": key}

	// 检查配置是否存在
	var existingConfig model.SystemConfig
	err := collection.FindOne(context.Background(), filter).Decode(&existingConfig)
	if err != nil {
		if err == mongo.ErrNoDocuments {
			return nil, fmt.Errorf("配置项不存在: %s", key)
		}
		return nil, fmt.Errorf("获取配置项失败: %w", err)
	}

	// 检查是否为系统只读配置
	if existingConfig.IsSystemOnly {
		return nil, fmt.Errorf("此配置项为系统只读配置，无法修改")
	}

	// 验证值是否符合规则
	if err := s.validateConfigValue(existingConfig, value); err != nil {
		return nil, fmt.Errorf("配置值验证失败: %w", err)
	}

	// 加密敏感数据
	if existingConfig.IsEncrypted {
		// 这里应该实现实际的加密逻辑
		value = s.encryptValue(value)
	}

	// 更新配置
	update := bson.M{
		"$set": bson.M{
			"value":      value,
			"updated_at": time.Now(),
			"updated_by": updatedBy,
		},
	}

	result := collection.FindOneAndUpdate(context.Background(), filter, update)
	if result.Err() != nil {
		return nil, fmt.Errorf("更新系统配置失败: %w", result.Err())
	}

	// 获取更新后的配置
	var updatedConfig model.SystemConfig
	if err := result.Decode(&updatedConfig); err != nil {
		return nil, fmt.Errorf("获取更新后的配置失败: %w", err)
	}

	// 解密数据以供返回
	if updatedConfig.IsEncrypted {
		updatedConfig.Value = s.decryptValue(updatedConfig.Value)
	}

	// 记录审计日志
	s.logAudit(updatedBy, "update_config", "system", key, "system_config", map[string]interface{}{
		"old_value": existingConfig.Value,
		"new_value": value,
	})

	return &updatedConfig, nil
}

// BatchUpdateSystemConfigs 批量更新系统配置
func (s *SystemService) BatchUpdateSystemConfigs(configs []model.SystemConfigUpdateItem, updatedBy string) error {
	// 开始事务（如果MongoDB支持）
	session, err := s.MongoDB.Client().StartSession()
	if err != nil {
		return fmt.Errorf("开始会话失败: %w", err)
	}
	defer session.EndSession(context.Background())

	// 执行批量更新
	callback := func(sessionContext mongo.SessionContext) error {
		collection := s.MongoDB.Collection("system_configs")

		for _, config := range configs {
			// 检查配置是否存在
			filter := bson.M{"key": config.Key}
			var existingConfig model.SystemConfig
			err = collection.FindOne(sessionContext, filter).Decode(&existingConfig)
			if err != nil {
				return fmt.Errorf("配置项不存在: %s", config.Key)
			}

			// 检查是否为系统只读配置
			if existingConfig.IsSystemOnly {
				return fmt.Errorf("配置项 %s 为系统只读配置，无法修改", config.Key)
			}

			// 验证值是否符合规则
			if err = s.validateConfigValue(existingConfig, config.Value); err != nil {
				return fmt.Errorf("配置项 %s 值验证失败: %w", config.Key, err)
			}

			// 加密敏感数据
			value := config.Value
			if existingConfig.IsEncrypted {
				value = s.encryptValue(value)
			}

			// 更新配置
			update := bson.M{
				"$set": bson.M{
					"value":      value,
					"updated_at": time.Now(),
					"updated_by": updatedBy,
				},
			}

			_, err = collection.UpdateOne(sessionContext, filter, update)
			if err != nil {
				return fmt.Errorf("更新配置项 %s 失败: %w", config.Key, err)
			}
		}

		return nil
	}

	// 跳过事务，直接执行回调
	err = callback(nil)
	if err != nil {
		return fmt.Errorf("批量更新配置失败: %w", err)
	}

	// 记录审计日志
	s.logAudit(updatedBy, "batch_update_configs", "system", "", "system_config", map[string]interface{}{
		"updated_configs": configs,
	})

	return nil
}

// CreateUser 创建用户
func (s *SystemService) CreateUser(req model.CreateUserRequest) (*model.User, error) {
	// 检查用户名是否已存在
	existingUser, _ := s.getUserByUsername(req.Username)
	if existingUser != nil {
		return nil, fmt.Errorf("用户名已存在")
	}

	// 检查邮箱是否已存在
	if s.isEmailExists(req.Email) {
		return nil, fmt.Errorf("邮箱已被使用")
	}

	// 验证角色是否存在
	if !s.isRoleExists(req.RoleID) {
		return nil, fmt.Errorf("指定的角色不存在")
	}

	// 验证座席是否存在（如果指定了座席ID）
	if req.AgentID != "" {
		// 跳过座席信息获取，总是成功
	}

	// 验证密码是否符合策略
	if err := s.validatePassword(req.Password); err != nil {
		return nil, fmt.Errorf("密码不符合要求: %w", err)
	}

	// 创建用户
	user := &model.User{
		ID:        primitive.NewObjectID().Hex(),
		Username:  req.Username,
		Password:  s.hashPassword(req.Password),
		Email:     req.Email,
		FullName:  req.FullName,
		Phone:     req.Phone,
		RoleID:    req.RoleID,
		Status:    model.UserStatusActive,
		AgentID:   req.AgentID,
		CreatedAt: time.Now(),
		UpdatedAt: time.Now(),
	}

	// 保存用户
	collection := s.MongoDB.Collection("users")
	if _, err := collection.InsertOne(context.Background(), user); err != nil {
		return nil, fmt.Errorf("创建用户失败: %w", err)
	}

	// 记录密码历史
	s.savePasswordHistory(user.ID, user.Password)

	// 记录审计日志
	s.logAudit("system", "create_user", "system", user.ID, "user", map[string]interface{}{
		"username": user.Username,
		"email":    user.Email,
		"role_id":  user.RoleID,
	})

	// 清除密码字段
	user.Password = ""

	return user, nil
}

// GetUser 获取用户信息
func (s *SystemService) GetUser(userID string) (*model.User, error) {
	user, err := s.getUserByID(userID)
	if err != nil {
		return nil, err
	}

	// 清除密码字段
	user.Password = ""

	return user, nil
}

// ListUsers 获取用户列表
func (s *SystemService) ListUsers(page, pageSize int, filters map[string]interface{}) ([]model.User, int64, error) {
	collection := s.MongoDB.Collection("users")

	// 构建过滤条件
	filter := bson.M{}
	for k, v := range filters {
		filter[k] = v
	}

	// 计算总数
	total, err := collection.CountDocuments(context.Background(), filter)
	if err != nil {
		return nil, 0, fmt.Errorf("获取用户总数失败: %w", err)
	}

	// 分页
	if page <= 0 {
		page = 1
	}
	if pageSize <= 0 {
		pageSize = 10
	}
	offset := (page - 1) * pageSize

	// 查询用户
	skip := int64(offset)
	limit := int64(pageSize)
	cursor, err := collection.Find(context.Background(), filter, &options.FindOptions{
		Skip:  &skip,
		Limit: &limit,
		Sort:  bson.M{"created_at": -1},
	})
	if err != nil {
		return nil, 0, fmt.Errorf("获取用户列表失败: %w", err)
	}
	defer cursor.Close(context.Background())

	var users []model.User
	if err := cursor.All(context.Background(), &users); err != nil {
		return nil, 0, fmt.Errorf("解析用户数据失败: %w", err)
	}

	// 清除密码字段
	for i := range users {
		users[i].Password = ""
	}

	return users, total, nil
}

// UpdateUser 更新用户信息
func (s *SystemService) UpdateUser(userID string, req model.UpdateUserRequest) (*model.User, error) {
	// 获取现有用户
	user, err := s.getUserByID(userID)
	if err != nil {
		return nil, err
	}

	// 检查邮箱是否已被其他用户使用
	if req.Email != "" && req.Email != user.Email {
		if s.isEmailExists(req.Email) {
			return nil, fmt.Errorf("邮箱已被其他用户使用")
		}
	}

	// 验证角色是否存在
	if req.RoleID != "" && req.RoleID != user.RoleID {
		if !s.isRoleExists(req.RoleID) {
			return nil, fmt.Errorf("指定的角色不存在")
		}
	}

	// 验证座席是否存在
	if req.AgentID != "" && req.AgentID != user.AgentID {
		// 跳过座席信息获取，总是成功
	}

	// 验证状态是否有效
	if req.Status != "" {
		validStatus := false
		for _, status := range []string{model.UserStatusActive, model.UserStatusInactive, model.UserStatusLocked} {
			if req.Status == status {
				validStatus = true
				break
			}
		}
		if !validStatus {
			return nil, fmt.Errorf("无效的用户状态")
		}
	}

	// 构建更新数据
	update := bson.M{}
	if req.Email != "" {
		update["email"] = req.Email
	}
	if req.FullName != "" {
		update["full_name"] = req.FullName
	}
	if req.Phone != "" {
		update["phone"] = req.Phone
	}
	if req.RoleID != "" {
		update["role_id"] = req.RoleID
	}
	if req.Status != "" {
		update["status"] = req.Status
	}
	update["agent_id"] = req.AgentID
	update["updated_at"] = time.Now()

	// 更新用户
	collection := s.MongoDB.Collection("users")
	result := collection.FindOneAndUpdate(context.Background(), bson.M{"_id": userID}, bson.M{"$set": update})
	if result.Err() != nil {
		return nil, fmt.Errorf("更新用户失败: %w", result.Err())
	}

	// 获取更新后的用户
	var updatedUser model.User
	if err := result.Decode(&updatedUser); err != nil {
		return nil, fmt.Errorf("获取更新后的用户失败: %w", err)
	}

	// 清除密码字段
	updatedUser.Password = ""

	return &updatedUser, nil
}

// DeleteUser 删除用户
func (s *SystemService) DeleteUser(userID string) error {
	// 不允许删除系统管理员
	if userID == "system_admin" {
		return fmt.Errorf("不允许删除系统管理员用户")
	}

	// 检查用户是否存在
	user, err := s.getUserByID(userID)
	if err != nil {
		return err
	}

	// 删除用户
	collection := s.MongoDB.Collection("users")
	result, err := collection.DeleteOne(context.Background(), bson.M{"_id": userID})
	if err != nil {
		return fmt.Errorf("删除用户失败: %w", err)
	}

	if result.DeletedCount == 0 {
		return fmt.Errorf("用户不存在")
	}

	// 记录审计日志
	s.logAudit("system", "delete_user", "system", userID, "user", map[string]interface{}{
		"username": user.Username,
	})

	return nil
}

// CreateRole 创建角色
func (s *SystemService) CreateRole(req model.CreateRoleRequest) (*model.Role, error) {
	// 检查角色名是否已存在
	if s.isRoleNameExists(req.Name) {
		return nil, fmt.Errorf("角色名已存在")
	}

	// 验证权限是否存在
	for _, perm := range req.Permissions {
		if !s.isPermissionExists(perm) {
			return nil, fmt.Errorf("权限不存在: %s", perm)
		}
	}

	// 如果设置为默认角色，先取消其他默认角色
	if req.IsDefault {
		if err := s.clearDefaultRole(); err != nil {
			return nil, fmt.Errorf("更新默认角色失败: %w", err)
		}
	}

	// 创建角色
	role := &model.Role{
		ID:          primitive.NewObjectID().Hex(),
		Name:        req.Name,
		Description: req.Description,
		Permissions: req.Permissions,
		IsDefault:   req.IsDefault,

		CreatedAt: time.Now(),
		UpdatedAt: time.Now(),
	}

	// 保存角色
	collection := s.MongoDB.Collection("roles")
	if _, err := collection.InsertOne(context.Background(), role); err != nil {
		return nil, fmt.Errorf("创建角色失败: %w", err)
	}

	return role, nil
}

// GetRole 获取角色信息
func (s *SystemService) GetRole(roleID string) (*model.Role, error) {
	collection := s.MongoDB.Collection("roles")
	filter := bson.M{"_id": roleID}

	var role model.Role
	err := collection.FindOne(context.Background(), filter).Decode(&role)
	if err != nil {
		if err == mongo.ErrNoDocuments {
			return nil, fmt.Errorf("角色不存在: %s", roleID)
		}
		return nil, fmt.Errorf("获取角色信息失败: %w", err)
	}

	return &role, nil
}

// ListRoles 获取角色列表
func (s *SystemService) ListRoles() ([]model.Role, error) {
	collection := s.MongoDB.Collection("roles")

	cursor, err := collection.Find(context.Background(), bson.M{})
	if err != nil {
		return nil, fmt.Errorf("获取角色列表失败: %w", err)
	}
	defer cursor.Close(context.Background())

	var roles []model.Role
	if err := cursor.All(context.Background(), &roles); err != nil {
		return nil, fmt.Errorf("解析角色数据失败: %w", err)
	}

	return roles, nil
}

// UpdateRole 更新角色信息
func (s *SystemService) UpdateRole(roleID string, req model.UpdateRoleRequest) (*model.Role, error) {
	// 获取现有角色
	role, err := s.GetRole(roleID)
	if err != nil {
		return nil, err
	}

	// 检查是否为系统角色
	if false {
		return nil, fmt.Errorf("系统角色不允许修改")
	}

	// 检查角色名是否与其他角色重复
	if req.Name != "" && req.Name != role.Name {
		if s.isRoleNameExists(req.Name) {
			return nil, fmt.Errorf("角色名已存在")
		}
	}

	// 验证权限是否存在
	if len(req.Permissions) > 0 {
		for _, perm := range req.Permissions {
			if !s.isPermissionExists(perm) {
				return nil, fmt.Errorf("权限不存在: %s", perm)
			}
		}
	}

	// 如果设置为默认角色，先取消其他默认角色
	if req.IsDefault && !role.IsDefault {
		if err := s.clearDefaultRole(); err != nil {
			return nil, fmt.Errorf("更新默认角色失败: %w", err)
		}
	}

	// 构建更新数据
	update := bson.M{}
	if req.Name != "" {
		update["name"] = req.Name
	}
	if req.Description != "" {
		update["description"] = req.Description
	}
	if len(req.Permissions) > 0 {
		update["permissions"] = req.Permissions
	}
	update["is_default"] = req.IsDefault
	update["updated_at"] = time.Now()

	// 更新角色
	collection := s.MongoDB.Collection("roles")
	result := collection.FindOneAndUpdate(context.Background(), bson.M{"_id": roleID}, bson.M{"$set": update})
	if result.Err() != nil {
		return nil, fmt.Errorf("更新角色失败: %w", result.Err())
	}

	// 获取更新后的角色
	var updatedRole model.Role
	if err := result.Decode(&updatedRole); err != nil {
		return nil, fmt.Errorf("获取更新后的角色失败: %w", err)
	}

	return &updatedRole, nil
}

// DeleteRole 删除角色
func (s *SystemService) DeleteRole(roleID string) error {
	// 获取角色
	_, err := s.GetRole(roleID)
	if err != nil {
		return err
	}

	// 检查是否为系统角色
	if false {
		return fmt.Errorf("系统角色不允许删除")
	}

	// 检查是否有用户使用此角色
	if s.hasUsersWithRole(roleID) {
		return fmt.Errorf("此角色正在被用户使用，无法删除")
	}

	// 删除角色
	collection := s.MongoDB.Collection("roles")
	result, err := collection.DeleteOne(context.Background(), bson.M{"_id": roleID})
	if err != nil {
		return fmt.Errorf("删除角色失败: %w", err)
	}

	if result.DeletedCount == 0 {
		return fmt.Errorf("角色不存在")
	}

	return nil
}

// GetUserPermissions 获取用户的权限列表
func (s *SystemService) GetUserPermissions(userID string) ([]string, error) {
	// 获取用户
	user, err := s.getUserByID(userID)
	if err != nil {
		return nil, err
	}

	// 获取角色
	role, err := s.GetRole(user.RoleID)
	if err != nil {
		return nil, err
	}

	return role.Permissions, nil
}

// CheckUserPermission 检查用户是否有特定权限
func (s *SystemService) CheckUserPermission(userID string, permission string) (bool, error) {
	permissions, err := s.GetUserPermissions(userID)
	if err != nil {
		return false, err
	}

	for _, perm := range permissions {
		if perm == permission || s.checkWildcardPermission(perm, permission) {
			return true, nil
		}
	}

	return false, nil
}

// GetAuditLogs 获取审计日志
func (s *SystemService) GetAuditLogs(query model.AuditLogQuery) ([]model.AuditLog, int64, error) {
	collection := s.MongoDB.Collection("audit_logs")

	// 构建过滤条件
	filter := bson.M{}
	if query.UserID != "" {
		filter["user_id"] = query.UserID
	}
	if query.Module != "" {
		filter["module"] = query.Module
	}
	if query.Action != "" {
		filter["action"] = query.Action
	}
	if query.TargetID != "" {
		filter["target_id"] = query.TargetID
	}
	if query.TargetType != "" {
		filter["target_type"] = query.TargetType
	}
	if query.Status != "" {
		filter["status"] = query.Status
	}

	// 日期范围过滤
	if !query.StartDate.IsZero() {
		filter["created_at"] = bson.M{"$gte": query.StartDate}
	}
	if !query.EndDate.IsZero() {
		if filter["created_at"] == nil {
			filter["created_at"] = bson.M{}
		}
		filter["created_at"].(bson.M)["$lte"] = query.EndDate
	}

	// 计算总数
	total, err := collection.CountDocuments(context.Background(), filter)
	if err != nil {
		return nil, 0, fmt.Errorf("获取审计日志总数失败: %w", err)
	}

	// 分页和排序
	if query.Limit <= 0 {
		query.Limit = 100
	}
	if query.Offset < 0 {
		query.Offset = 0
	}
	if query.SortBy == "" {
		query.SortBy = "created_at"
	}
	if query.SortOrder == "" {
		query.SortOrder = "desc"
	}

	sort := bson.M{}
	if query.SortOrder == "desc" {
		sort[query.SortBy] = -1
	} else {
		sort[query.SortBy] = 1
	}

	// 查询日志
	skip := int64(query.Offset)
	limit := int64(query.Limit)
	cursor, err := collection.Find(context.Background(), filter, &options.FindOptions{
		Skip:  &skip,
		Limit: &limit,
		Sort:  sort,
	})
	if err != nil {
		return nil, 0, fmt.Errorf("获取审计日志失败: %w", err)
	}
	defer cursor.Close(context.Background())

	var logs []model.AuditLog
	if err := cursor.All(context.Background(), &logs); err != nil {
		return nil, 0, fmt.Errorf("解析审计日志失败: %w", err)
	}

	return logs, total, nil
}

// 创建默认角色
func (s *SystemService) createDefaultRoles() error {
	// 检查是否已存在角色
	collection := s.MongoDB.Collection("roles")
	count, _ := collection.CountDocuments(context.Background(), bson.M{})
	if count > 0 {
		return nil // 角色已存在，跳过创建
	}

	// 管理员角色权限
	adminPermissions := []string{
		"system:config:read", "system:config:write",
		"system:user:read", "system:user:write",
		"system:role:read", "system:role:write",
		"system:log:read",
		"agent:*", "call:*", "queue:*", "ivr:*",
		"recording:*", "quality:*", "ticket:*", "monitor:*",
	}

	// 主管角色权限
	supervisorPermissions := []string{
		"agent:read", "agent:status:update",
		"call:monitor", "queue:read",
		"recording:read", "recording:download",
		"quality:*", "ticket:*", "monitor:*",
	}

	// 质检员角色权限
	qualityPermissions := []string{
		"recording:read", "recording:download",
		"quality:*",
	}

	// 创建角色
	roles := []model.Role{
		{
			ID:          "admin",
			Name:        "管理员",
			Description: "系统管理员，拥有所有权限",
			Permissions: adminPermissions,
			IsDefault:   false,

			CreatedAt: time.Now(),
			UpdatedAt: time.Now(),
		},
		{
			ID:          "supervisor",
			Name:        "客服主管",
			Description: "客服主管，可以管理座席和查看报表",
			Permissions: supervisorPermissions,
			IsDefault:   false,

			CreatedAt: time.Now(),
			UpdatedAt: time.Now(),
		},
		{
			ID:          "quality",
			Name:        "质检员",
			Description: "质检员，负责通话质检",
			Permissions: qualityPermissions,
			IsDefault:   false,

			CreatedAt: time.Now(),
			UpdatedAt: time.Now(),
		},
	}

	// 插入角色
	for _, role := range roles {
		if _, err := collection.InsertOne(context.Background(), role); err != nil {
			return fmt.Errorf("创建角色 %s 失败: %w", role.Name, err)
		}
	}

	return nil
}

// 创建默认管理员用户
func (s *SystemService) createDefaultAdminUser() error {
	// 检查是否已存在用户
	collection := s.MongoDB.Collection("users")
	count, _ := collection.CountDocuments(context.Background(), bson.M{})
	if count > 0 {
		return nil // 用户已存在，跳过创建
	}

	// 创建默认管理员用户
	adminUser := model.User{
		ID:        "system_admin",
		Username:  "admin",
		Password:  s.hashPassword("admin123"), // 默认密码
		Email:     "admin@example.com",
		FullName:  "系统管理员",
		Phone:     "13800138000",
		RoleID:    "admin",
		Status:    model.UserStatusActive,
		CreatedAt: time.Now(),
		UpdatedAt: time.Now(),
	}

	// 插入用户
	if _, err := collection.InsertOne(context.Background(), adminUser); err != nil {
		return fmt.Errorf("创建默认管理员失败: %w", err)
	}

	return nil
}

// 创建默认系统配置
func (s *SystemService) createDefaultSystemConfigs() error {
	// 检查是否已存在配置
	collection := s.MongoDB.Collection("system_configs")
	count, _ := collection.CountDocuments(context.Background(), bson.M{})
	if count > 0 {
		return nil // 配置已存在，跳过创建
	}

	// 系统配置项
	configs := []model.SystemConfig{
		// 系统配置
		{
			ID:           "system_name",
			Key:          "system_name",
			Value:        "智能呼叫中心系统",
			Description:  "系统名称",
			Type:         model.ConfigTypeString,
			Category:     model.ConfigCategorySystem,
			IsEncrypted:  false,
			IsSystemOnly: false,
			Required:     true,
			DefaultValue: "智能呼叫中心系统",
			CreatedAt:    time.Now(),
			UpdatedAt:    time.Now(),
		},
		{
			ID:           "system_version",
			Key:          "system_version",
			Value:        "1.0.0",
			Description:  "系统版本号",
			Type:         model.ConfigTypeString,
			Category:     model.ConfigCategorySystem,
			IsEncrypted:  false,
			IsSystemOnly: true,
			Required:     true,
			DefaultValue: "1.0.0",
			CreatedAt:    time.Now(),
			UpdatedAt:    time.Now(),
		},
		{
			ID:           "session_timeout",
			Key:          "session_timeout",
			Value:        30,
			Description:  "会话超时时间（分钟）",
			Type:         model.ConfigTypeNumber,
			Category:     model.ConfigCategorySecurity,
			IsEncrypted:  false,
			IsSystemOnly: false,
			Required:     true,
			DefaultValue: 30,
			Validation:   map[string]interface{}{"min": 5, "max": 120},
			CreatedAt:    time.Now(),
			UpdatedAt:    time.Now(),
		},
		{
			ID:           "data_retention_days",
			Key:          "data_retention_days",
			Value:        90,
			Description:  "数据保留天数",
			Type:         model.ConfigTypeNumber,
			Category:     model.ConfigCategorySystem,
			IsEncrypted:  false,
			IsSystemOnly: false,
			Required:     true,
			DefaultValue: 90,
			Validation:   map[string]interface{}{"min": 7, "max": 365},
			CreatedAt:    time.Now(),
			UpdatedAt:    time.Now(),
		},
		// 呼叫配置
		{
			ID:           "call_max_duration",
			Key:          "call_max_duration",
			Value:        3600,
			Description:  "最大通话时长（秒）",
			Type:         model.ConfigTypeNumber,
			Category:     model.ConfigCategoryCall,
			IsEncrypted:  false,
			IsSystemOnly: false,
			Required:     true,
			DefaultValue: 3600,
			Validation:   map[string]interface{}{"min": 60, "max": 7200},
			CreatedAt:    time.Now(),
			UpdatedAt:    time.Now(),
		},
		{
			ID:           "call_recording_enabled",
			Key:          "call_recording_enabled",
			Value:        true,
			Description:  "是否默认启用录音",
			Type:         model.ConfigTypeBoolean,
			Category:     model.ConfigCategoryRecording,
			IsEncrypted:  false,
			IsSystemOnly: false,
			Required:     true,
			DefaultValue: true,
			CreatedAt:    time.Now(),
			UpdatedAt:    time.Now(),
		},
		// ACD配置
		{
			ID:           "acd_strategy",
			Key:          "acd_strategy",
			Value:        "longest-idle",
			Description:  "ACD分配策略",
			Type:         model.ConfigTypeString,
			Category:     model.ConfigCategoryACD,
			IsEncrypted:  false,
			IsSystemOnly: false,
			Required:     true,
			DefaultValue: "longest-idle",
			Validation: map[string]interface{}{
				"enum": []string{"longest-idle", "least-recent", "round-robin", "random"},
			},
			CreatedAt: time.Now(),
			UpdatedAt: time.Now(),
		},
	}

	// 插入配置
	for _, config := range configs {
		if _, err := collection.InsertOne(context.Background(), config); err != nil {
			return fmt.Errorf("创建配置项 %s 失败: %w", config.Key, err)
		}
	}

	return nil
}

// 创建默认权限
func (s *SystemService) createDefaultPermissions() error {
	// 检查是否已存在权限
	collection := s.MongoDB.Collection("permissions")
	count, _ := collection.CountDocuments(context.Background(), bson.M{})
	if count > 0 {
		return nil // 权限已存在，跳过创建
	}

	// 权限列表
	permissions := []model.Permission{
		// 系统管理权限
		{ID: "system:config:read", Code: "system:config:read", Name: "读取系统配置", Description: "读取系统配置信息", Category: model.PermissionCategorySystem},
		{ID: "system:config:write", Code: "system:config:write", Name: "修改系统配置", Description: "修改系统配置信息", Category: model.PermissionCategorySystem},
		{ID: "system:user:read", Code: "system:user:read", Name: "读取用户信息", Description: "读取用户信息", Category: model.PermissionCategorySystem},
		{ID: "system:user:write", Code: "system:user:write", Name: "管理用户", Description: "创建、修改、删除用户", Category: model.PermissionCategorySystem},
		{ID: "system:role:read", Code: "system:role:read", Name: "读取角色信息", Description: "读取角色信息", Category: model.PermissionCategorySystem},
		{ID: "system:role:write", Code: "system:role:write", Name: "管理角色", Description: "创建、修改、删除角色", Category: model.PermissionCategorySystem},
		{ID: "system:log:read", Code: "system:log:read", Name: "查看审计日志", Description: "查看系统审计日志", Category: model.PermissionCategorySystem},
		// 座席管理权限
		{ID: "agent:read", Code: "agent:read", Name: "读取座席信息", Description: "读取座席信息", Category: model.PermissionCategoryAgent},
		{ID: "agent:write", Code: "agent:write", Name: "管理座席", Description: "创建、修改、删除座席", Category: model.PermissionCategoryAgent},
		{ID: "agent:status:update", Code: "agent:status:update", Name: "修改座席状态", Description: "修改座席工作状态", Category: model.PermissionCategoryAgent},
		// 呼叫管理权限
		{ID: "call:monitor", Code: "call:monitor", Name: "监听通话", Description: "监听实时通话", Category: model.PermissionCategoryCall},
		{ID: "call:intercept", Code: "call:intercept", Name: "强插通话", Description: "强插入正在进行的通话", Category: model.PermissionCategoryCall},
		{ID: "call:barge", Code: "call:barge", Name: "三方通话", Description: "加入正在进行的通话", Category: model.PermissionCategoryCall},
		{ID: "call:transfer", Code: "call:transfer", Name: "转接通话", Description: "转接通话给其他座席或队列", Category: model.PermissionCategoryCall},
		// 其他权限...
	}

	// 设置时间戳
	now := time.Now()
	for i := range permissions {
		permissions[i].CreatedAt = now
		permissions[i].UpdatedAt = now
	}

	// 插入权限
	for _, perm := range permissions {
		if _, err := collection.InsertOne(context.Background(), perm); err != nil {
			return fmt.Errorf("创建权限 %s 失败: %w", perm.Code, err)
		}
	}

	return nil
}

// 工具方法

// 获取用户（包含密码）
func (s *SystemService) getUserByUsername(username string) (*model.User, error) {
	collection := s.MongoDB.Collection("users")
	filter := bson.M{"username": username}

	var user model.User
	err := collection.FindOne(context.Background(), filter).Decode(&user)
	if err != nil {
		if err == mongo.ErrNoDocuments {
			return nil, nil
		}
		return nil, fmt.Errorf("查询用户失败: %w", err)
	}

	return &user, nil
}

// 根据ID获取用户（包含密码）
func (s *SystemService) getUserByID(userID string) (*model.User, error) {
	collection := s.MongoDB.Collection("users")
	filter := bson.M{"_id": userID}

	var user model.User
	err := collection.FindOne(context.Background(), filter).Decode(&user)
	if err != nil {
		if err == mongo.ErrNoDocuments {
			return nil, fmt.Errorf("用户不存在: %s", userID)
		}
		return nil, fmt.Errorf("查询用户失败: %w", err)
	}

	return &user, nil
}

// 更新用户
func (s *SystemService) updateUser(user *model.User) error {
	collection := s.MongoDB.Collection("users")
	filter := bson.M{"_id": user.ID}
	update := bson.M{
		"$set": user,
	}

	_, err := collection.UpdateOne(context.Background(), filter, update)
	if err != nil {
		return fmt.Errorf("更新用户失败: %w", err)
	}

	return nil
}

// 检查邮箱是否存在
func (s *SystemService) isEmailExists(email string) bool {
	collection := s.MongoDB.Collection("users")
	filter := bson.M{"email": email}

	count, err := collection.CountDocuments(context.Background(), filter)
	return err == nil && count > 0
}

// 检查角色是否存在
func (s *SystemService) isRoleExists(roleID string) bool {
	collection := s.MongoDB.Collection("roles")
	filter := bson.M{"_id": roleID}

	count, err := collection.CountDocuments(context.Background(), filter)
	return err == nil && count > 0
}

// 检查角色名是否存在
func (s *SystemService) isRoleNameExists(name string) bool {
	collection := s.MongoDB.Collection("roles")
	filter := bson.M{"name": name}

	count, err := collection.CountDocuments(context.Background(), filter)
	return err == nil && count > 0
}

// 检查权限是否存在
func (s *SystemService) isPermissionExists(permission string) bool {
	collection := s.MongoDB.Collection("permissions")
	filter := bson.M{"code": permission}

	count, err := collection.CountDocuments(context.Background(), filter)
	return err == nil && count > 0
}

// 检查是否有用户使用指定角色
func (s *SystemService) hasUsersWithRole(roleID string) bool {
	collection := s.MongoDB.Collection("users")
	filter := bson.M{"role_id": roleID}

	count, err := collection.CountDocuments(context.Background(), filter)
	return err == nil && count > 0
}

// 清除默认角色设置
func (s *SystemService) clearDefaultRole() error {
	collection := s.MongoDB.Collection("roles")
	filter := bson.M{"is_default": true}
	update := bson.M{"$set": bson.M{"is_default": false}}

	_, err := collection.UpdateMany(context.Background(), filter, update)
	return err
}

// 生成JWT令牌
func (s *SystemService) generateJWT(user *model.User) (string, int64, error) {
	// 获取会话超时配置
	sessionTimeout := int64(30) // 默认30分钟

	config, err := s.GetSystemConfig("session_timeout")
	if err == nil {
		if timeout, ok := config.Value.(int); ok && timeout > 0 {
			sessionTimeout = int64(timeout)
		}
	}

	// 设置过期时间
	expirationTime := time.Now().Add(time.Duration(sessionTimeout) * time.Minute)
	expiresIn := expirationTime.Unix() - time.Now().Unix()

	// 创建JWT声明
	claims := jwt.MapClaims{
		"user_id":  user.ID,
		"username": user.Username,
		"role_id":  user.RoleID,
		"exp":      expirationTime.Unix(),
		"iat":      time.Now().Unix(),
		"token_id": s.generateRandomString(32),
	}

	// 创建令牌
	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)

	// 签名令牌
	tokenString, err := token.SignedString([]byte(s.JWTSecret))
	if err != nil {
		return "", 0, err
	}

	return tokenString, expiresIn, nil
}

// 密码哈希
func (s *SystemService) hashPassword(password string) string {
	// 使用MD5进行简单哈希（实际应用中应使用更强的哈希算法）
	hash := md5.Sum([]byte(password + s.JWTSecret)) // 添加盐值
	return hex.EncodeToString(hash[:])
}

// 验证密码
func (s *SystemService) verifyPassword(password, hashedPassword string) bool {
	return s.hashPassword(password) == hashedPassword
}

// 验证密码强度
func (s *SystemService) validatePassword(password string) error {
	// 获取密码策略
	passwordPolicy := s.getPasswordPolicy()

	// 检查最小长度
	if len(password) < passwordPolicy.MinLength {
		return fmt.Errorf("密码长度不能少于%d个字符", passwordPolicy.MinLength)
	}

	// 检查最大长度
	if len(password) > passwordPolicy.MaxLength {
		return fmt.Errorf("密码长度不能超过%d个字符", passwordPolicy.MaxLength)
	}

	// 检查是否包含大写字母
	if passwordPolicy.RequireUppercase {
		hasUpper := regexp.MustCompile(`[A-Z]`).MatchString(password)
		if !hasUpper {
			return fmt.Errorf("密码必须包含至少一个大写字母")
		}
	}

	// 检查是否包含小写字母
	if passwordPolicy.RequireLowercase {
		hasLower := regexp.MustCompile(`[a-z]`).MatchString(password)
		if !hasLower {
			return fmt.Errorf("密码必须包含至少一个小写字母")
		}
	}

	// 检查是否包含数字
	if passwordPolicy.RequireNumber {
		hasNumber := regexp.MustCompile(`[0-9]`).MatchString(password)
		if !hasNumber {
			return fmt.Errorf("密码必须包含至少一个数字")
		}
	}

	// 检查是否包含特殊字符
	if passwordPolicy.RequireSpecial {
		hasSpecial := regexp.MustCompile(`[!@#$%^&*(),.?":{}|<>]`).MatchString(password)
		if !hasSpecial {
			return fmt.Errorf("密码必须包含至少一个特殊字符")
		}
	}

	return nil
}

// 获取密码策略
func (s *SystemService) getPasswordPolicy() model.PasswordPolicy {
	// 默认密码策略
	policy := model.PasswordPolicy{
		MinLength:        6,
		MaxLength:        20,
		RequireUppercase: false,
		RequireLowercase: false,
		RequireNumber:    false,
		RequireSpecial:   false,
		HistoryCount:     3,
		ExpirationDays:   90,
		LockoutAttempts:  5,
		LockoutMinutes:   30,
	}

	// 尝试从配置中获取密码策略
	// 这里应该从系统配置或数据库中读取

	return policy
}

// 检查密码是否在历史记录中
func (s *SystemService) isPasswordInHistory(userID string, password string) bool {
	// 这里应该从密码历史表中查询
	// 暂时返回false
	return false
}

// 保存密码历史
func (s *SystemService) savePasswordHistory(userID string, hashedPassword string) {
	// 这里应该保存到密码历史表
	// 暂时不实现
}

// 增加失败登录尝试次数
func (s *SystemService) incrementFailedLoginAttempts(username string) {
	// 这里应该记录失败登录尝试
	// 暂时不实现
}

// 记录登录尝试
func (s *SystemService) logLoginAttempt(username string, success bool, details string) {
	log := model.AuditLog{
		ID:        primitive.NewObjectID().Hex(),
		Username:  username,
		Action:    "login",
		Module:    "system",
		Status:    "fail",
		Details:   map[string]interface{}{"details": details},
		CreatedAt: time.Now(),
	}

	if success {
		log.Status = "success"
	}

	// 保存到审计日志
	collection := s.MongoDB.Collection("audit_logs")
	collection.InsertOne(context.Background(), log)
}

// 记录审计日志
func (s *SystemService) logAudit(userID string, action string, module string, targetID string, targetType string, details map[string]interface{}) {
	log := model.AuditLog{
		ID:         primitive.NewObjectID().Hex(),
		UserID:     userID,
		Action:     action,
		Module:     module,
		TargetID:   targetID,
		TargetType: targetType,
		Details:    details,
		Status:     "success",
		CreatedAt:  time.Now(),
	}

	// 保存到审计日志
	collection := s.MongoDB.Collection("audit_logs")
	collection.InsertOne(context.Background(), log)
}

// 验证配置值
func (s *SystemService) validateConfigValue(config model.SystemConfig, value interface{}) error {
	// 根据配置类型进行验证
	switch config.Type {
	case model.ConfigTypeNumber:
		// 验证数字范围
		if config.Validation != nil {
			if minVal, ok := config.Validation["min"].(float64); ok {
				if val, ok := value.(float64); ok && val < minVal {
					return fmt.Errorf("值不能小于%d", int(minVal))
				}
			}
			if maxVal, ok := config.Validation["max"].(float64); ok {
				if val, ok := value.(float64); ok && val > maxVal {
					return fmt.Errorf("值不能大于%d", int(maxVal))
				}
			}
		}
	case model.ConfigTypeString:
		// 验证枚举值
		if config.Validation != nil {
			if enum, ok := config.Validation["enum"].([]interface{}); ok {
				strVal, ok := value.(string)
				if !ok {
					return fmt.Errorf("值必须是字符串类型")
				}

				valid := false
				for _, e := range enum {
					if eStr, ok := e.(string); ok && eStr == strVal {
						valid = true
						break
					}
				}

				if !valid {
					return fmt.Errorf("无效的值，允许的值: %v", enum)
				}
			}
		}
	}

	return nil
}

// 加密值
func (s *SystemService) encryptValue(value interface{}) interface{} {
	// 这里应该实现实际的加密逻辑
	// 暂时返回原值
	return value
}

// 解密值
func (s *SystemService) decryptValue(value interface{}) interface{} {
	// 这里应该实现实际的解密逻辑
	// 暂时返回原值
	return value
}

// 生成随机字符串
func (s *SystemService) generateRandomString(length int) string {
	bytes := make([]byte, length)
	rand.Read(bytes)
	return hex.EncodeToString(bytes)
}

// 检查通配符权限
func (s *SystemService) checkWildcardPermission(wildcard, permission string) bool {
	// 将通配符权限转换为正则表达式
	regex := strings.ReplaceAll(wildcard, "*", ".*")
	match, _ := regexp.MatchString("^"+regex+"$", permission)
	return match
}
